packages/dashmate/src/listr/tasks/setup/local/configureCoreTaskFactory.js (3)

Line range hint 126-150: Refactor duplicated block generation logic into a reusable function

The code for generating blocks to reach a certain activation height is duplicated in both the 'Activating v19 and v20' and 'Activating v21 fork' tasks. Refactor this logic into a separate function to improve maintainability and reduce code duplication.

Consider creating a function like generateBlocksUntilHeight and reuse it in both tasks:

+ const generateBlocksUntilHeight = async (targetHeight, observer) => {
+   const blocksToGenerateInOneStep = 10;
+   let blocksGenerated = 0;
+   let { result: currentBlockHeight } = await ctx.coreService.getRpcClient().getBlockCount();
+
+   do {
+     ({ result: currentBlockHeight } = await ctx.coreService.getRpcClient().getBlockCount());
+     await generateBlocks(
+       ctx.coreService,
+       blocksToGenerateInOneStep,
+       NETWORK_LOCAL,
+       (blocks) => {
+         blocksGenerated += blocks;
+         observer.next(`${blocksGenerated} blocks generated`);
+       },
+     );
+   } while (targetHeight > currentBlockHeight);
+ };

Then update the tasks to use this function:

// In 'Activating v19 and v20' task
task: () => new Observable(async (observer) => {
- const dip3ActivationHeight = 901;
- const blocksToGenerateInOneStep = 10;
- let blocksGenerated = 0;
- let {
-   result: currentBlockHeight,
- } = await ctx.coreService.getRpcClient().getBlockCount();
-
- do {
-   ({
-     result: currentBlockHeight,
-   } = await ctx.coreService.getRpcClient().getBlockCount());
-
-   await generateBlocks(
-     ctx.coreService,
-     blocksToGenerateInOneStep,
-     NETWORK_LOCAL,
-     // eslint-disable-next-line no-loop-func
-     (blocks) => {
-       blocksGenerated += blocks;
-
-       observer.next(`${blocksGenerated} blocks generated`);
-     },
-   );
- } while (dip3ActivationHeight > currentBlockHeight);
+ await generateBlocksUntilHeight(901, observer);
  observer.complete();
  return this;
}),

// Similarly in 'Activating v21 fork' task
task: () => new Observable(async (observer) => {
- const dip3ActivationHeight = 1001;
+ await generateBlocksUntilHeight(1001, observer);
  observer.complete();
  return this;
}),

Also applies to: 312-338

---

230-231: Address the TODO comment: Rename function for clarity

There's a TODO comment indicating that the function waitForMasternodesSync should be renamed, possibly to better reflect its functionality. Updating the function name will improve code readability and maintainability.

Would you like assistance in renaming the function and updating references throughout the codebase? I can help generate the necessary changes or open a GitHub issue to track this task.

---

291-293: Enhance error message for masternode status check

The error message 'Not all masternodes are enabled' could be more informative by specifying which masternodes are not enabled. This can aid in debugging and expedite issue resolution.

Consider modifying the error handling to include the IDs or statuses of the non-enabled masternodes:

if (hasNotEnabled) {
- throw new Error('Not all masternodes are enabled');
+ const disabledMNs = Object.entries(masternodesStatus)
+   .filter(([, status]) => status !== 'ENABLED')
+   .map(([proTxHash, status]) => `${proTxHash}: ${status}`);
+ throw new Error(`The following masternodes are not enabled:\n${disabledMNs.join('\n')}`);
}

packages/dashmate/src/status/scopes/platform.js (1)

316-316: Update platform activation message for better user feedback

When the platform activation is pending, enhancing the activation message with additional context can improve user experience and clarity.

Consider including the current block height and the number of blocks remaining until activation:

if (mnRRSoftFork.active) {
  scope.platformActivation = `Activated (at height ${mnRRSoftFork.height})`;
} else {
+ const { result: currentBlockHeight } = await rpcClient.getBlockCount();
+ const blocksRemaining = mnRRSoftFork.height - currentBlockHeight;
+ scope.platformActivation = `Waiting for activation at height ${mnRRSoftFork.height} (current height: ${currentBlockHeight}, ${blocksRemaining} blocks remaining)`;
}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

#!/bin/bash
# Description: Compare RPC methods between Core versions 21 and 22 to identify changes.

# Pull Docker images if not already present
docker pull dashpay/dashd:21 > /dev/null
docker pull dashpay/dashd:22 > /dev/null

# Get list of RPC methods from Core version 21
docker run --rm dashpay/dashd:21 dash-cli help > rpc_methods_v21.txt

# Get list of RPC methods from Core version 22
docker run --rm dashpay/dashd:22 dash-cli help > rpc_methods_v22.txt

# Compare the lists to find differences
diff rpc_methods_v21.txt rpc_methods_v22.txt > rpc_methods_diff.txt

# Output the differences
echo "Differences in RPC methods between Core v21 and Core v22:"
cat rpc_methods_diff.txt

#!/bin/bash
# Search for RPC method calls in the codebase
echo "Files containing RPC method calls:"
rg -l "\.rpc\." --type js

echo -e "\nDetailed RPC method usage:"
rg "\.rpc\." -A 2 --type js

echo -e "\nSearch for Core version references:"
rg -i "core.*version|dashd.*version" --type js

packages/dashmate/src/listr/tasks/setup/local/configureCoreTaskFactory.js (2)

116-124: Add validation and progress reporting for funds generation

Consider these improvements:

1. Validate that the seed node has sufficient mining power before starting
2. Add progress reporting to track fund generation
3. Add a timeout mechanism to prevent infinite waiting

 title: 'Generating funds to use as a collateral for masternodes',
-task: () => {
+task: () => new Observable(async (observer) => {
   const amount = HPMN_COLLATERAL_AMOUNT * configGroup.length;
+  observer.next(`Generating ${amount} DASH for ${configGroup.length} masternodes`);
+
+  const timeout = setTimeout(() => {
+    throw new Error('Fund generation timed out after 10 minutes');
+  }, 10 * 60 * 1000);
+
   return generateToAddressTask(
     configGroup.find((c) => c.getName() === 'local_seed'),
     amount,
-  );
-},
+  ).finally(() => {
+    clearTimeout(timeout);
+    observer.complete();
+  });
+}),

---

Line range hint 126-338: Refactor duplicate block generation logic

The block generation logic is duplicated between v19/v20 and v21 activation tasks. Consider extracting this into a reusable function.

+async function generateUntilHeight(targetHeight, ctx, observer) {
+  const blocksToGenerateInOneStep = 10;
+  let blocksGenerated = 0;
+  
+  let { result: currentBlockHeight } = await ctx.coreService.getRpcClient().getBlockCount();
+  
+  while (targetHeight > currentBlockHeight) {
+    ({ result: currentBlockHeight } = await ctx.coreService.getRpcClient().getBlockCount());
+    
+    await generateBlocks(
+      ctx.coreService,
+      blocksToGenerateInOneStep,
+      NETWORK_LOCAL,
+      (blocks) => {
+        blocksGenerated += blocks;
+        observer.next(`${blocksGenerated} blocks generated`);
+      },
+    );
+  }
+}

 // Usage in tasks:
 {
   title: 'Activating v19 and v20',
   task: () => new Observable(async (observer) => {
     await generateUntilHeight(901, ctx, observer);
     observer.complete();
     return this;
   }),
 },
 // ... other tasks ...
 {
   title: 'Activating v21 fork',
   task: () => new Observable(async (observer) => {
     await generateUntilHeight(1001, ctx, observer);
     observer.complete();
     return this;
   }),
 },

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro